class Pen {    private int color; // private field        // public property    public int Color     {          get        {            return this.color;        }        set         {            if (value > 0) {                this.color = value;            }        }    }}

// accessing:Pen pen = new Pen();int color_tmp = 0;//...pen.Color = 17;color_tmp = pen.Color;//...pen.Color = ~pen.Color; // bitwise complement...// another silly example:pen.Color += 1; // a lot clearer than "pen.set_Color(pen.get_Color() + 1)"!

#include <iostream>template <typename T> class property {        T value;    public:        T & operator = (const T &i) {            return value = i;        }        // This template class member function template serves the purpose to make        // typing more strict. Assignment to this is only possible with exact identical        // types.        template <typename T2> T2 & operator = (const T2 &i) {            T2 &guard = value;            throw guard; // Never reached.        }        // Implicit conversion back to T.         operator T const & () const {            return value;        }};struct Foo {    // Properties using unnamed classes.    class {            int value;        public:            int & operator = (const int &i) { return value = i; }            operator int () const { return value; }    } alpha;    class {            float value;        public:            float & operator = (const float &f) { return value = f; }            operator float () const { return value; }    } bravo;};struct Bar {    // Using the property<>-template.    property <bool> alpha;    property <unsigned int> bravo;};int main () {    Foo foo;    foo.alpha = 5;    foo.bravo = 5.132f;    Bar bar;    bar.alpha = true;    bar.bravo = true; // This line will yield a compile time error                      // due to the guard template member function.::std::cout << foo.alpha << ", "                << foo.bravo << ", "                << bar.alpha << ", "                << bar.bravo                <<::std::endl;    return 0;}

// declspec_property.cppstruct S{   int i;   void putprop(int j)   {       i = j;   }   int getprop()   {      return i;   }   __declspec(property(get = getprop, put = putprop)) int the_prop;};int main(){   S s;   s.the_prop = 5;   return s.the_prop;}

class Pen{    private int m_color; // private field        // public get property    public int color () {        return m_color;    }        // public set property    public void color (int value) {         m_color = value;    }}

auto pen = new Pen;pen.color = ~pen.color; // bitwise complement// the set property can also be used in expressions, just like regular assignmentint theColor = (pen.color = 0xFF0000);

class Pen{    private int m_color; // private field        // public get property    @property public int color () {        return m_color;    }        // public set property    @property public void color (int value) {        m_color = value;    }}

type TPen = class  private    FColor: TColor;    function GetColor: TColor;    procedure SetColor(const AValue: TColor);  public    property Color: Integer read GetColor write SetColor;end;function TPen.GetColor: TColor;begin  Result:= FColor;end;procedure TPen.SetColor(const AValue: TColor);begin  if FColor <> AValue   then FColor:= AValue;end;

// accessing:var Pen: TPen;//...Pen.Color:= not Pen.Color;(*Delphi also supports a 'direct field' syntax -property Color: TColor read FColor write SetColor;orproperty Color: TColor read GetColor write FColor;where the compiler generates the exact same code as for reading and writinga field. This offers the efficiency of a field, with the safety of a property.(You can't get a pointer to the property, and you can always replace the memberaccess with a method call.)*)

class Pen {   // private data member   Color color;public:   // public property   property Color color    {        get { return color; }      set { color = value; }   }}Pen blackPen { color = black };Pen whitePen { color = white };Pen pen3 { color = { 30, 80, 120 } };Pen pen4 { color = ColorHSV { 90, 20, 40 } };

type Pen() = class    let mutable _color = 0    member this.Color        with get() = _color        and set value = _color <- valueend

let pen = new Pen()pen.Color <- ~~~pen.Color

function Pen() {    this._color = 0;}// Add the property to the Pen type itself, can also// be set on the instance individuallyObject.defineProperties(Pen.prototype, {    color: {        get: function () {            return this._color;        },        set: function (value) {            this._color = value;        }    }});

var pen = new Pen();pen.color = ~pen.color; // bitwise complementpen.color += 1; // Add one

package  {	public class Pen {		private var _color:uint = 0;				public function get color():uint {			return _color;		}				public function set color(value:uint):void {			_color = value;		}	}}

var pen:Pen = new Pen();pen.color = ~pen.color; // bitwise complementpen.color += 1; // add one

@interface Pen: NSObject@property (copy) NSColor *colour;	// The "copy" attribute causes the object's copy to be					// retained, instead of the original.@end@implementation Pen@synthesize colour;			// Compiler directive to synthesise accessor methods.					// It can be left behind in Xcode 4.5 and later.@end

Pen *pen = [[Pen alloc] init];pen.colour = [NSColor blackColor];float red = pen.colour.redComponent;[pen.colour drawSwatchInRect: NSMakeRect(0, 0, 100, 100)];

class Pen {    private $_color;    function __set($property, $value) {        if ($property == 'Color') {             return $this->_color = $value;        }    }    function __get($property) {        if ($property == 'Color') {            return $this->_color;        }    }}

$p = new Pen();$p->Color = ~$p->Color; // bitwise complementecho $p->Color;

class Pen(object):    def __init__(self):        self._color = 0 # "private" variable    @property    def color(self):        return self._color    @color.setter    def color(self, color):        self._color = color

pen = Pen()# accessing:pen.color = ~pen.color # bitwise complement...

class Pen    def initialize        @color = 0    end        # Defines a getter for the @color field    def color        @color    end    # Defines a setter for the @color field    def color=(value)        @color = value    endendpen = Pen.newpen.color = ~pen.color    # Bitwise complement

Public Class Pen     Private _color As Integer ' Private field    Public Property Color() As Integer ' Public property        Get            Return _color        End Get        Set(ByVal value As Integer)            _color = value        End Set    End PropertyEnd Class

' Create Pen class instanceDim pen As New Pen()' Set valuepen.Color = 1' Get valueDim color As Int32 = pen.Color

Public Class Pen    Public Property Color() As Integer ' Public propertyEnd Class

' Create Pen class instanceDim pen As New Pen()' Set valuepen.Color = 1' Get valueDim color As Int32 = pen.Color

' in a class named clsPenPrivate m_Color As LongPublic Property Get Color() As Long    Color = m_ColorEnd PropertyPublic Property Let Color(ByVal RHS As Long)    m_Color = RHSEnd Property

' accessing:Dim pen As New clsPen'...pen.Color = Not pen.Color